home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet internetowy / Rozne / HTTrack 3.40-2 / httrack-3.40-2.exe / {app} / src / minizip / iowin32.c < prev    next >
C/C++ Source or Header  |  2005-09-24  |  6KB  |  276 lines
  1. /* iowin32.c -- IO base function header for compress/uncompress .zip
  2.    files using zlib + zip or unzip API
  3.    This IO API version uses the Win32 API (for Microsoft Windows)
  4.  
  5.    Version 1.00, September 10th, 2003
  6.  
  7.    Copyright (C) 1998-2003 Gilles Vollant
  8. */
  9.  
  10. #include <stdlib.h>
  11. #ifndef _WIN32_WCE
  12. #include <stdlib.h>
  13. #else
  14. //#include "celib.h"
  15. #endif
  16.  
  17. #include "zlib.h"
  18. #include "ioapi.h"
  19. #include "iowin32.h"
  20.  
  21. #ifndef INVALID_HANDLE_VALUE
  22. #define INVALID_HANDLE_VALUE (0xFFFFFFFF)
  23. #endif
  24.  
  25. #ifndef INVALID_SET_FILE_POINTER
  26. #define INVALID_SET_FILE_POINTER ((DWORD)-1)
  27. #endif
  28.  
  29. voidpf ZCALLBACK win32_open_file_func OF((
  30.    voidpf opaque,
  31.    const char* filename,
  32.    int mode));
  33.  
  34. uLong ZCALLBACK win32_read_file_func OF((
  35.    voidpf opaque,
  36.    voidpf stream,
  37.    void* buf,
  38.    uLong size));
  39.  
  40. uLong ZCALLBACK win32_write_file_func OF((
  41.    voidpf opaque,
  42.    voidpf stream,
  43.    const void* buf,
  44.    uLong size));
  45.  
  46. long ZCALLBACK win32_tell_file_func OF((
  47.    voidpf opaque,
  48.    voidpf stream));
  49.  
  50. long ZCALLBACK win32_seek_file_func OF((
  51.    voidpf opaque,
  52.    voidpf stream,
  53.    uLong offset,
  54.    int origin));
  55.  
  56. int ZCALLBACK win32_close_file_func OF((
  57.    voidpf opaque,
  58.    voidpf stream));
  59.  
  60. int ZCALLBACK win32_error_file_func OF((
  61.    voidpf opaque,
  62.    voidpf stream));
  63.  
  64. typedef struct
  65. {
  66.     HANDLE hf;
  67.     int error;
  68. } WIN32FILE_IOWIN;
  69.  
  70. voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode)
  71.    voidpf opaque;
  72.    const char* filename;
  73.    int mode;
  74. {
  75.     const char* mode_fopen = NULL;
  76.     DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
  77.     HANDLE hFile = 0;
  78.     voidpf ret=NULL;
  79.  
  80.     dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0;
  81.  
  82.     if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
  83.     {
  84.         dwDesiredAccess = GENERIC_READ;
  85.         dwCreationDisposition = OPEN_EXISTING;
  86.         dwShareMode = FILE_SHARE_READ;
  87.     }
  88.     else
  89.     if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
  90.     {
  91.         dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
  92.         dwCreationDisposition = OPEN_EXISTING;
  93.     }
  94.     else
  95.     if (mode & ZLIB_FILEFUNC_MODE_CREATE)
  96.     {
  97.         dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
  98.         dwCreationDisposition = CREATE_ALWAYS;
  99.     }
  100.  
  101.     if ((filename!=NULL) && (dwDesiredAccess != 0))
  102.         hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL,
  103.                       dwCreationDisposition, dwFlagsAndAttributes, NULL);
  104.  
  105.     if (hFile == INVALID_HANDLE_VALUE)
  106.         hFile = NULL;
  107.  
  108.     if (hFile != NULL)
  109.     {
  110.         WIN32FILE_IOWIN w32fiow;
  111.         w32fiow.hf = hFile;
  112.         w32fiow.error = 0;
  113.         ret = malloc(sizeof(WIN32FILE_IOWIN));
  114.         if (ret==NULL)
  115.             CloseHandle(hFile);
  116.         else *((WIN32FILE_IOWIN*)ret) = w32fiow;
  117.     }
  118.     return ret;
  119. }
  120.  
  121.  
  122. uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size)
  123.    voidpf opaque;
  124.    voidpf stream;
  125.    void* buf;
  126.    uLong size;
  127. {
  128.     uLong ret=0;
  129.     HANDLE hFile = NULL;
  130.     if (stream!=NULL)
  131.         hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
  132.     if (hFile != NULL)
  133.         if (!ReadFile(hFile, buf, size, &ret, NULL))
  134.         {
  135.             DWORD dwErr = GetLastError();
  136.             if (dwErr == ERROR_HANDLE_EOF)
  137.                 dwErr = 0;
  138.             ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
  139.         }
  140.  
  141.     return ret;
  142. }
  143.  
  144.  
  145. uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size)
  146.    voidpf opaque;
  147.    voidpf stream;
  148.    const void* buf;
  149.    uLong size;
  150. {
  151.     uLong ret=0;
  152.     HANDLE hFile = NULL;
  153.     if (stream!=NULL)
  154.         hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
  155.  
  156.     if (hFile !=NULL)
  157.         if (!WriteFile(hFile, buf, size, &ret, NULL))
  158.         {
  159.             DWORD dwErr = GetLastError();
  160.             if (dwErr == ERROR_HANDLE_EOF)
  161.                 dwErr = 0;
  162.             ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
  163.         }
  164.  
  165.     return ret;
  166. }
  167.  
  168. long ZCALLBACK win32_tell_file_func (opaque, stream)
  169.    voidpf opaque;
  170.    voidpf stream;
  171. {
  172.     long ret=-1;
  173.     HANDLE hFile = NULL;
  174.     if (stream!=NULL)
  175.         hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
  176.     if (hFile != NULL)
  177.     {
  178.         DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
  179.         if (dwSet == INVALID_SET_FILE_POINTER)
  180.         {
  181.             DWORD dwErr = GetLastError();
  182.             ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
  183.             ret = -1;
  184.         }
  185.         else
  186.             ret=(long)dwSet;
  187.     }
  188.     return ret;
  189. }
  190.  
  191. long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin)
  192.    voidpf opaque;
  193.    voidpf stream;
  194.    uLong offset;
  195.    int origin;
  196. {
  197.     DWORD dwMoveMethod=0xFFFFFFFF;
  198.     HANDLE hFile = NULL;
  199.  
  200.     long ret=-1;
  201.     if (stream!=NULL)
  202.         hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
  203.     switch (origin)
  204.     {
  205.     case ZLIB_FILEFUNC_SEEK_CUR :
  206.         dwMoveMethod = FILE_CURRENT;
  207.         break;
  208.     case ZLIB_FILEFUNC_SEEK_END :
  209.         dwMoveMethod = FILE_END;
  210.         break;
  211.     case ZLIB_FILEFUNC_SEEK_SET :
  212.         dwMoveMethod = FILE_BEGIN;
  213.         break;
  214.     default: return -1;
  215.     }
  216.  
  217.     if (hFile != NULL)
  218.     {
  219.         DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod);
  220.         if (dwSet == INVALID_SET_FILE_POINTER)
  221.         {
  222.             DWORD dwErr = GetLastError();
  223.             ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
  224.             ret = -1;
  225.         }
  226.         else
  227.             ret=0;
  228.     }
  229.     return ret;
  230. }
  231.  
  232. int ZCALLBACK win32_close_file_func (opaque, stream)
  233.    voidpf opaque;
  234.    voidpf stream;
  235. {
  236.     int ret=-1;
  237.  
  238.     if (stream!=NULL)
  239.     {
  240.         HANDLE hFile;
  241.         hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
  242.         if (hFile != NULL)
  243.         {
  244.             CloseHandle(hFile);
  245.             ret=0;
  246.         }
  247.         free(stream);
  248.     }
  249.     return ret;
  250. }
  251.  
  252. int ZCALLBACK win32_error_file_func (opaque, stream)
  253.    voidpf opaque;
  254.    voidpf stream;
  255. {
  256.     int ret=-1;
  257.     if (stream!=NULL)
  258.     {
  259.         ret = ((WIN32FILE_IOWIN*)stream) -> error;
  260.     }
  261.     return ret;
  262. }
  263.  
  264. void fill_win32_filefunc (pzlib_filefunc_def)
  265.   zlib_filefunc_def* pzlib_filefunc_def;
  266. {
  267.     pzlib_filefunc_def->zopen_file = win32_open_file_func;
  268.     pzlib_filefunc_def->zread_file = win32_read_file_func;
  269.     pzlib_filefunc_def->zwrite_file = win32_write_file_func;
  270.     pzlib_filefunc_def->ztell_file = win32_tell_file_func;
  271.     pzlib_filefunc_def->zseek_file = win32_seek_file_func;
  272.     pzlib_filefunc_def->zclose_file = win32_close_file_func;
  273.     pzlib_filefunc_def->zerror_file = win32_error_file_func;
  274.     pzlib_filefunc_def->opaque=NULL;
  275. }
  276.